#ifndef __LOCKFREE_BUFFER_H__
#define __LOCKFREE_BUFFER_H__

#include <cstdint>
#include <cstring>
#include <algorithm>
#include <vector>

namespace utools::mem
{
    /// @brief 无锁循环缓冲区
    class LockFreeBuffer
    {
    private:
        uint8_t *__buffer;      // 数据缓冲区
        size_t __capacity;      // 缓冲区容量
        size_t __capacity_mask; // 缓冲区容量掩码
        size_t __head;          // 写入指针
        size_t __tail;          // 读取指针

        /// @brief 计算下一个2的n次方
        /// @param value 原始值
        /// @return 下一个2的n次方
        static size_t __next_power_of_two(size_t value)
        {
            if (value == 0)
                return 1;
            size_t power = 1;
            while (power < value)
            {
                power <<= 1; // 左移1位，相当于乘以2
            }
            return power;
        }

    public:
        // 构造函数，确保容量为 2 的 n 次方
        LockFreeBuffer(size_t capacity)
            : __capacity(__next_power_of_two(capacity)), __capacity_mask(__capacity - 1), __head(0), __tail(0)
        {
            __buffer = new uint8_t[__capacity];
        }

        // 析构函数
        ~LockFreeBuffer()
        {
            delete[] __buffer;
        }

        /// @brief 清空缓冲区
        void clear()
        {
            __head = 0;
            __tail = 0;
        }

        /// @brief 写入数据
        /// @param data 数据指针
        /// @param len 数据长度
        /// @return 是否写入成功
        bool write(const void *data, size_t len)
        {
            if (len > available())
            {
                return false; // 缓冲区不足以写入数据
            }

            // 检查可用空间
            size_t next_head = (__head + len) & __capacity_mask; // 使用位运算计算下一个写入位置
            if (next_head == __tail)
            {
                return false; // 缓冲区已满
            }

            // 写入数据
            memcpy(&__buffer[__head], data, len);
            __head = next_head; // 更新写入指针
            return true;        // 写入成功
        }

        /// @brief 写入数据
        /// @param data 数据指针
        /// @param len 数据长度
        /// @return 是否写入成功
        bool write(const std::vector<uint8_t> &data)
        {
            return write(data.data(), data.size());
        }

        /// @brief 读取数据
        /// @param data 数据指针
        /// @param len 读取长度
        /// @return 实际读取的数据长度
        size_t read(void *data, size_t len)
        {
            // 检查是否有数据可读
            if (__head == __tail)
            {
                return 0; // 缓冲区为空
            }

            size_t read_len = 0;
            while (__tail != __head && read_len < len)
            {
                size_t available = (__head - __tail) & __capacity_mask; // 当前可读取的有效数据
                size_t to_copy = std::min(len - read_len, available);
                memcpy(static_cast<uint8_t *>(data) + read_len, &__buffer[__tail], to_copy);
                read_len += to_copy;
                __tail = (__tail + to_copy) & __capacity_mask; // 更新读取指针
            }
            return read_len; // 返回实际读取的长度
        }

        /// @brief 读取数据
        /// @param len 读取长度
        /// @return 实际读取的数据
        std::vector<uint8_t> read(size_t len)
        {
            std::vector<uint8_t> data(len);
            size_t actual_read_len = read(data.data(), len);
            data.resize(actual_read_len); // 调整大小以匹配实际读取的字节数
            return data;
        }

        /// @brief 读取全部可读取数据
        /// @return 数据
        std::vector<uint8_t> read_all()
        {
            std::vector<uint8_t> data(size());
            read(data.data(), data.size());
            return data;
        }

        /// @brief 获取缓冲区大小
        /// @return 当前数据大小
        size_t size() const
        {
            return (__head - __tail) & __capacity_mask;
        }

        /// @brief 获取缓冲区容量
        /// @return 缓冲区最大容量
        size_t capacity() const
        {
            return __capacity;
        }

        /// @brief 获取缓冲区剩余空间
        /// @return 缓冲区剩余空间大小
        size_t available() const
        {
            return __capacity - size() - 1; // 减去一个字节的预留空间
        }

        /// @brief 获取缓冲区是否为空
        /// @return true 为空，false 不为空
        bool empty() const
        {
            return __head == __tail;
        }
    };
}

#endif // __LOCKFREE_BUFFER_H__
